﻿#define  _CRT_SECURE_NO_WARNINGS


#include <iostream>
using namespace std;






// 隐式类型转换explicit，static静态成员函数/变量，友元函数/类，内部类，编译器附加优化，OJ题1.匿名对象2.日期到天数转换3.日期差值，new和delete关键字





// 类和对象（下）










// 隐式类型转换
// 
// 
// 
// 自定义类型中含有单参数的构造函数，就能支持 隐式类型转换
// C++11，之后，
// 自定义类型中含有多参数的构造函数，也能支持，饮食类型转换
// 
// 
// explicit关键字
// 拒绝 自定义类型支持单参数的构造函数，进行隐式类型转化
// 
// 
// 
// 
// 
// 
// 
// 单参数的构造函数
// 
// 
// 
//class A
//{
//public:
//	// 构造函数
//	explicit A(const int a)
//		:_a1(a)
//	{
//		cout << "A(const int a)" << endl;
//	}
//
//	//explicit A(const int a , const int b)
//	A(const int a, const int b)
//		:_a1(a)
//	{
//		cout << "A(const int a , const int b)" << endl;
//	}
//
//	//  拷贝构造函数
//	A(const A& aa)
//		:_a1(aa._a1)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//
//private:
//	int _a1;
//	//int _a2;
//};
//
//
//int main()
//{
//
//	// 单参数的构造函数 C++98
//
// 
// 
// 
//	A aa1(1); // 直接调用构造函数
//
//	// 增加explicit关键字，拒绝 单参数构造函数 的隐式转化功能  构造函数 标记为 显示 即可
//
//	//A aa2 = 1;// 自定义类型支持单参数的构造函数，就能支持 隐式类型转换
//			  // 
//			  // 本质上是隐式类型转换：
//			  //						构造函数 + 拷贝构造函数
//			  // 先创建一个临时的A类的对象，调用构造函数传参1 实例化临时对象
//			  // 之后aa2调用拷贝构造函数，使用临时的A类对象 实例化aa2对象
//			  // 
//			  // 
//			  // 
//			  // 但实际上编译器会进行优化：（新的编译器会进行优化）
//			  // 隐式类型转换   ---->    直接调用 构造函数
//			  //
//
//	//A& ref = 10;// 不行 
//				// 临时构造的A类临时对象 具有常性const（临时变量具有常性const）
//				// 用A& 来引用 发生权限扩大
//				// 需要用 const A& 来引用
//				// 
//	//const A& ref = 10;
//
//
// 
// 
// 
// 
// 
// 
// 
// 
// 
//	// 多参数的构造函数 C++11
//
// 
// 
// 
//	A aa2(1, 1);
//	// C++11 支持 多参数构造函数 的隐式转化功能
//	// 同理 拒绝 多参数构造函数 的隐式转化功能 增加explicit 标记为 显示 即可
//	A aa3 = { 2,2 }; 
//	const A& ref = { 3,3 };// 也是隐式类型转化
//
//
//	int i = 1;
//	double d = i;// 隐式类型转换，会先创建一个double类型的临时变量（具有常性）
//				 // 把i赋值给double类型的临时变量，临时变量在赋值给d
//
//
//	return 0;
//}
// 






















// static静态成员
// 
// static成员变量  和  static成员函数
// 
// 
// 
// 实现一个类，计算程序中该类所创建出了多少个类对象。
// 
// 
// 
// 
// 
// 方法一：
// 
// 思路：
// 如果要通过该类创建类对象，一定需要通过 构造函数 或 拷贝构造函数 才行。
// 
// 
// 
// 如果在全局展开C++库 std，会导致count变量与std库中的冲突
// 所以 部分展开 需要的用的std库中的东西
//using std::cout;
//using std::endl;
//
//
//int count = 0;
//
//
//class A
//{
//public:
//	A(int a = 0)
//	{
//		count++;
//	}
//	A(const A& aa)
//	{
//		count++;
//	}
//};
//
////void func(A a)// 会调用拷贝构造函数
//void func(A& a)// 不会调用拷贝构造函数
//
//{
//
//}
//
//int main()
//{
//	A aa1;
//	A aa2(aa1);
//	func(aa1);
//	A aa3 = 1;
//
//
//	// 问题：1.命名冲突 2.谁都可以修改全局变量count
//	count++;
//	count++;
//	count--;
//
//
//	cout << count << endl;
//
//	return 0;
//}
// 





// 
// 方法二：
// 
// 将count放入一个类里面，count不能属于所创建的某一个对象，需要count属于这个类
// 
// 
// 
// 
// 
// 
// 
// 类成员变量 增加 static关键字   -----    静态成员变量
// 
// 
// static int count;受到A类域的限制，不会和在全局中变量产生冲突
//using namespace std;
//
//class A
//{
//public:
//	A(int a = 0)
//	{
//		count++;
//	}
//	A(const A& aa)
//	{
//		count++;
//	}
//
//
//
//
//
//	// 通过成员方法，返回静态成员变量的数据
//	//int GetCount()
//	//{
//      // 只要是public 指明静态成员变量的命名空间域，就可以访问到静态成员变量
//	//	return count;
//	//}
//	
//	// 修改为没有隐含this指针的类成员函数
//	// 即可以不通过 类实例化对象 来调用该函数，只需要指明该static int GetCount()是属于那个命名空间域中的函数
//	static int GetCount()
//	{
//		// _a++; // 由于没有this指针，所以不能直接访问非静态成员变量
//
//		return count;
//	}
//
//
//
//
//private:
//	// 不属于该类的某一个实例化对象，属于所有的该类的对象，属于整个类
//	// 存储在静态区中
//	// 对象实例化时，初始化列表不会定义初始化 static修饰的静态成员变量
//	static int count; // 只是声明
//};
//
//// 在类声明外，对类中的静态成员变量进行 定义初始化
//int A::count = 0; // 定义初始化
//
//
//
//
//
//
//
////void func(A a)// 会调用拷贝构造函数
//void func()// 不会调用拷贝构造函数
//{
//	A aa1;
//	A aa2(aa1);
//	A aa3 = 1;
//
//	// 创建一个含有10个自定义类型A元素 的数组，需要调用10次构造函数
//	A aa4[10];
//}
//
//
//
//
//
//
//
//int main()
//{
//	func();
//
//	// 如何访问静态成员变量
//	// 
//	// 只要是public 指明静态成员变量的命名空间域，就可以访问到静态成员变量
//	// 
//	// 
//	// 
//	// 突破 类命名空间域 找到count来访问
//	// 下面的方式：需要解除count为private私有成员变量
//	//cout << A::count << endl;
//	
//	//cout << aa1.count << endl;// 可以通过 该类实例化的任意一个对象，调用来访问静态成员变量
//	//cout << aa2.count << endl;
//	//cout << aa3.count << endl;
//	
//	//A* ptr = nullptr;// 虽然是空指针，没有发生解引用
//	//cout << ptr->count << endl;// 通过ptr指针所指向的类型A，找到count声明为static，存储在静态区，直接在静态区找count数据
//
//
//
//
//
//	// 若为count为private私有 成员变量
//	// 
//	// 需要调用成员函数，返回count的具体值
//	//A aa1;
//	//cout << aa1.GetCount() << endl;
//
//
//	// 问题，如果没有实例化的类对象，该如何获得count数据？
//	// 
//	// 更改 GetCount() 函数，增加static关键字，
//	// 使类成员函数，变为没有this指针的成员函数
//	// 即可以不通过 类实例化对象 来调用该函数，只需要指明该static int GetCount()是属于那个命名空间域中的函数
//	cout << A::GetCount() << endl;
//
//	A* ptr = nullptr;
//	cout << ptr->GetCount() << endl;
//
//
//	return 0;
//}
// 
























// 
// 友元
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 友元函数
//  		将流运算符的运算符重载函数，设置为友元函数，使该函数可以访问private或protected的成员变量
// 
// 
// 缺点：破坏了封装，增加了耦合度
// 能不用就不用
// 
// 
//class Date
//{
//    // 友元函数声明
//    friend ostream& operator<<(ostream& _cout, const Date& d);
//    friend istream& operator>>(istream& _cin, Date& d);
//
//public:
//    Date(int year = 1900, int month = 1, int day = 1)
//        : _year(year)
//        , _month(month)
//        , _day(day)
//    {}
//
//private:
//    int _year;
//    int _month;
//    int _day;
//};
//
//
//// 流提取运算符重载
//ostream& operator<<(ostream& _cout, const Date& d)
//{
//    _cout << d._year << "-" << d._month << "-" << d._day;
//    return _cout;
//}
//// 流插入运算符重载
//istream& operator>>(istream& _cin, Date& d)
//{
//    _cin >> d._year;
//    _cin >> d._month;
//    _cin >> d._day;
//    return _cin;
//}
//
//
//
//int main()
//{
//    Date d;
//
//    cin >> d;
//    cout << d << endl;
//
//    return 0;
//}
// 
// 
// 
// 注意：
// 
// 1.友元函数可访问类的私有和保护成员，但不是类的成员函数   ---  没有this指针
//
// 2.友元函数不能用const修饰   ---  只有非静态的成员函数才能用const修饰，需要有this指针
//
// 3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制
//
// 4.一个函数可以是多个类的友元函数
//
// 5.友元函数的调用与普通函数的调用原理相同
// 
// 











// 
// 友元类
// 
// 
// 
// 注意：
// 那个类中的成员变量被允许访问，哪一个类中就需要写出声明
// Time类中的成员变量被允许访问，Time类就需要写出声明，friend class Date;
// 
// Date类是Time类的友元类，所以 Date类 就可以访问 Time类的所有成员变量
// 
// 
// 
// 1.友元是单向关系，没有交换性
// 
// 2.友元关系不能传递
// 
// 3.友元关系不能继承
// 
// 
//class Time
//{
//    friend class Date;// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
//public:
//    Time(int hour = 0, int minute = 0, int second = 0)
//        : _hour(hour)
//        , _minute(minute)
//        , _second(second)
//    {}
//private:
//    int _hour;
//    int _minute;
//    int _second;
//};
//class Date
//{
//public:
//    Date(int year = 1900, int month = 1, int day = 1)
//        : _year(year)
//        , _month(month)
//        , _day(day)
//    {}
//    void SetTimeOfDate(int hour, int minute, int second)
//    {
//        // 直接访问时间类私有的成员变量
//        _t._hour = hour;
//        _t._minute = minute;
//        _t._second = second;
//    }
//private:
//    int _year;
//    int _month;
//    int _day;
//
//    Time _t;
//};
// 











//
// 内部类
// 
// 如果一个类定义在另一个类的内部，这个内部类就叫做内部类。
// 
// 
// 
// 注意：内部类就是外部类的友元类
// 
// 
// 
// 特点：
//      1.内部类受到外部类的类域限制
//      2.内部类天生就是外部类的友元类
// 
// 
// 
//class A
//{
//private:
//    int h = 1;
//    static int k;
//public:
//    // 内部类
//    class B// B天生就是A的友元
//    {
//    public:
//        void foo(const A& a)
//        {
//            cout << k << endl;// k为A类静态成员变量，访问限定没问题，所以只需要确定域即可访问，而通过定义即可找到域
//            cout << c << endl;// c为B类静态成员变量，同理
//            cout << a.h << endl;// h 为A类中的成员变量，但B类同属于A类中的一部分（友元类）可以访问A类private私有成员变量
//            cout << b << endl;
//            
//        }
//
//    private:
//        int b = 2;
//        static int c;
//    };
//};
//
//int A::k = 1;
//int A::B::c = 1;
//
//int main()
//{
//    A aa;
//    cout << sizeof(aa) << endl;// 结果 4
//    // 内部类就是定义在一个类里面，和定义在全局存储本质并没有什么区别，仅仅是受到A类的类域限制
//
//    // 例如：实例化一个B类的对象，需要指定在A的类中去寻找 B类的声明
//    A::B bb;
//    // 若B类在A类中，被限定为了private私有则即使指定了在A类域中寻找，也不能访问B类（不可访问）
//
//
//    return 0;
//}
// 
// 
// 
// 
//












//
//
// 练习题
//
// 
// 
// 匿名对象
// 
// 
// 1.求1 + 2 + 3 + ... + n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)
// https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking
//
// 
// 利用构造函数 和 静态成员变量，通过n次调用构造函数实现 1+2+3+。。。+n
// 
//class Sum
//{
//public:
//    // 构造函数
//    Sum()
//    {
//        // 每当调用一次构造函数，就会让_Sum 累加 _i，之后再_i++
//        _Sum += _i;
//        ++_i;
//    }
//
//    // 静态成员函数，用来返回静态成员变量的值
//    static int GetNum()
//    {
//        // 静态成员变量，由于没有this指针，所以只能访问该类中的静态成员变量
//        return _Sum;
//    }
//
//    ~Sum()
//    {
//        cout << "~Sum()" << endl;
//    }
//
//private:
//    // 用于累加的静态成员变量
//    static int _Sum;
//    static int _i;
//};
//
//// 定义并初始化静态成员变量
//int Sum::_Sum = 0;
//int Sum::_i = 1;
//
//
//
//
//class Solution {
//public:
//    int Sum_Solution(int n) {
//        //Sum a[n];
//        // 不支持变长数组C99
//        Sum* ptr = new Sum[n];
//        return Sum::GetNum();
//    }
//
//    // 析构函数
//    ~Solution()
//    {
//        cout << "~Solution()" << endl;
//    }
//};
//
//// 如果要直接返回一个对象，可以直接构造一个匿名对象进行返回
//
//int main()
//{
//    //Solution s;
//    //cout << s.Sum_Solution(10) << endl;
//
//    // 不能这样定义对象，分不清是函数的声明，还是定义对象
//    //Solution s1();
//
//    // 匿名对象  ---  生命周期只在这一行，过了这一行该对象就销毁
//    Solution();
//    //Sum();
//
//
//    // 使用匿名对象简化代码
//    cout << Solution().Sum_Solution(10) << endl;
// 
//    return 0;
//}
// 
// 
// 
// 
// 
// 
// 
// 防止Sum类被随意使用，通过内部类进行改造
// 在Solution类中将Sum类设置为private私有类，Sum将无法被Solution类以外的访问
// 
// 
// 

//class Solution
//{
//public:
//    int Sum_Solution(int n)
//    {
//        //Sum a[n];
//        // 不支持变长数组C99
//        Sum* ptr = new Sum[n];
//        return _Sum;
//    }
//
//private:
//    // 内部类Sum
//    class Sum// 天生是Solution的友元类
//    {
//    public:
//        // 构造函数
//        Sum()
//        {
//            // 每当调用一次构造函数，就会让_Sum 累加 _i，之后再_i++
//            _Sum += _i;
//            ++_i;
//        }
//    };
//    // 用于累加的静态成员变量
//    static int _Sum;
//    static int _i;
//};
//
//// 定义并初始化静态成员变量
//int Solution::_Sum = 0;
//int Solution::_i = 1;
//















// 编译器的附加优化
// 
// 
// 
// 
// 
// 
// 
// 
// 
//class A
//{
//public:
//	// 构造函数
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	
//	// 拷贝构造函数
//	A(const A& aa)
//		:_a(aa._a)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//
//	// 赋值运算符重载
//	A& operator=(const A& aa)
//	{
//		cout << "A& operator=(const A& aa)" << endl;
//		if (this != &aa)
//		{
//			_a = aa._a;
//		}
//		return *this;
//	}
//
//	// 析构函数
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a;
//};
//
//void func1(A aa)
//{
//
//}
//
//void func2(const A& aa)
//{
//
//}
//
//A func3()
//{
//	A aa;
//	int a = 1;
//	return aa;
//}
//
//A func4()
//{
//	return A();
//}

//int main()
//{
//	// 1.隐式类型转换explicit
//	
//	// 构造函数+拷贝构造函数  ==  直接构造函数
//	// 连续多个拷贝构造函数  ==  直接首和尾进行拷贝构造函数
//	//A aa1 = 1;
//
//	
//	
//	
//	// 2.传参 和 传返回值
//	
//	// 传值传参
//	// 
//	// 
//	//func1(aa1);// 不优化
//	//func1(2);//构造+拷贝构造 = 直接构造
//	//func1(A(3));//构造+拷贝构造 = 直接构造
//	
//
//
//	// 引用传参
//	// 
//	// 
//	// 引用传参不修改形参的话，形参尽量增加const 修饰，既可以接受可读可写的，又可以接受只读的实参
//	//func2(aa1);// 不需要优化
//	//func2(2);// 错误：临时变量具有常性const      不需要优化
//	//func2(A(3));// 错误：匿名对象具有常性const   不需要优化
//	
//
//
//
//
//
//	// 传值返回
//	// 
//	// 
//	//func3();
//	// vs2013 :
//	// 
//	// A(int a)
//	// A(const A& aa)
//	// ~A()
//	// ~A()
//	// 
//	// vs2022:
//	// 
//	// A(int a)
//	// ~A()
//	// 
//	// 
//	// 
//	//A aa1;
//	//aa1 = func3();// 赋值重载函数 --  不能和其他构造函数/拷贝构造函数 进行优化
//	// vs2013
//	// A(int a)
//	// A(int a)
//	// A(const A& aa)
//	// ~A()
//	// A& operator=(const A & aa)
//	// ~A()
//	// ~A()
//	// 
//	// vs2022
//	// A(int a)
//	// A(int a)
//	// A& operator=(const A & aa)
//	// ~A()
//	// ~A()
//	//
//	// 
//	// 
//	// A aa1 = func3();// 优化 拷贝构造+ 拷贝构造
//	// vs2013 :
//	//
//	// A(int a)
//	// A(const A& aa)
//	// ~A()
//	// ~A()
//	// 
//	// vs2022:	
//	// 
//	// A(int a)
//	// ~A()
//
//
//
//	//func4();// 优化 构造 + 拷贝构造  = 优化为直接构造
//	// vs2013:	
//	// A(int a)
//	// ~A()
//	// 
//	// vs2022:	
//	// A(int a)
//	// ~A()
//	// 
//	// 
//	// 
//	//A aa2 = func4();// 优化 构造 + 拷贝构造 + 拷贝构造  =  优化为直接构造
//	// vs2013:	
//	// A(int a)
//	// ~A()
//	// 
//	// vs2022:	
//	// A(int a)
//	// ~A()
//
//
//
//
//
//
//
//
//	// 总结：
//	// 
//	// 传参：
//	// 1.传参 尽量使用 const & 作为形参
//	// 
//	// 
//	// 传值返回：
//	// 1.接收 自定义类型变量 的返回值，尽量 拷贝构造 接收，不要 赋值运算符重载 接收
//	// 2.函数中 传值返回 对象时，尽量返回 匿名对象
//	//
//
//
//
//	return 0;
//}
// 
// 












// 
// 
//
// 2.计算日期到天数的转换
// https://www.nowcoder.com/practice/769d45d455fe40b385ba32f97e7bcded?tpId=37&&tqId=21296&rp=1&ru=/activity/oj&qru=/ta/huawei/question-ranking
//
// 
// 日期问题，多使用数组，进行计算
// 
// 
//#include <iostream>
//using namespace std;
//
//int main()
//{
//    int year = 0, month = 0, day = 0;
//    cin >> year >> month >> day;
//
//    int monthDay1_N[] = { 0,31,59,90,120,151,181,212,243,273,304,334,365 };
//
//    int nday = monthDay1_N[month - 1] + day;
//    if (month > 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
//        ++nday;
//    cout << nday << endl;
//}







// 
// 3.日期差值
// https://www.nowcoder.com/practice/ccb7383c76fc48d2bbc27a2a6319631c?tpId=62&&tqId=29468&rp=1&ru=/activity/oj&qru=/ta/sju-kaoyan/question-ranking
//
// 
//#include <iostream>
//using namespace std;
//
//
//class Date
//{
//public:
//    Date(int num = 0)
//        : _year(num / 10000)
//        , _month(num % 10000 / 100)
//        , _day(num % 100) {
//
//    }
//
//    int GetMonthDay(const Date& d) const
//    {
//        int monthDay[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//        int mday = monthDay[d._month];
//        if (d._year % 4 == 0 && d._year % 100 != 0 || d._year % 400 == 0)
//        {
//            mday++;
//        }
//        return mday;
//    }
//
//    void operator++()
//    {
//        _day += 1;
//        if (_day > GetMonthDay(*this))
//        {
//            _day = 1;
//            _month += 1;
//            if (_month == 13)
//            {
//                _month = 1;
//                _year += 1;
//            }
//        }
//    }
//
//    bool operator<(const Date& d) const
//    {
//        return _year < d._year
//            || _year == d._year && _month < d._month
//            || _year == d._year && _month == d._month && _day < d._day;
//    }
//
//    int operator-(const Date& d) const
//    {
//        Date max(*this);
//        Date min(d);
//
//        if (*this < d)
//        {
//            max = d;
//            min = *this;
//        }
//
//        int n = 1;
//        while (min < max)
//        {
//            ++min;
//            ++n;
//        }
//
//        return n;
//    }
//
//
//private:
//    int _year;
//    int _month;
//    int _day;
//};
//
//
//int main()
//{
//
//    int num1 = 0, num2 = 0;
//    cin >> num1 >> num2;
//    Date d1(num1);
//    Date d2(num2);
//
//    cout << d1 - d2 << endl;
//
//    return 0;
//}
// 
//
//  4.打印日期
// https://www.nowcoder.com/practice/b1f7a77416194fd3abd63737cdfcf82b?tpId=69&&tqId=29669&rp=1&ru=/activity/oj&qru=/ta/hust-kaoyan/question-ranking
//
//
// 5.累加天数
// https://www.nowcoder.com/practice/eebb2983b7bf40408a1360efb33f9e5d?tpId=40&&tqId=31013&rp=1&ru=/activity/oj&qru=/ta/kaoyan/question-ranking


















// Lesson05--C / C++内存管理
//
// 
// 
//  【本节目标】
// 
// 1. C / C++内存分布
// 2. C语言中动态内存管理方式
// 3. C++中动态内存管理
// 4. operator new与operator delete函数
// 5. new和delete的实现原理
// 6. 定位new表达式(placement - new)
// 7. 常见面试题
//









// 2. C语言中动态内存管理方式
// 
// malloc/calloc/realloc的区别:
// 
// malloc    ---    开辟空间不初始化
// calloc    ---    内存空间会初始化为0 ，参数列表 个数 + 类型
// realloc   ---    对已有的空间进行扩容（自动分辨完成：原地扩容/异地扩容 -- 自动搬运数据和释放原数据所在的内存空间）
// 
// 
//

//int mian()
//{
//	int* p1 = (int*)malloc(sizeof(int));
//	free(p1);
//
//	int* p2 = (int*)calloc(4, sizeof(int));
//	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
//	free(p3);
//
//	return 0;
//}












// 3. C++中动态内存管理
// 
// new和delete操作自定义类型
// 
// 
// 




class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};


int main()
{

	// 单个对象开辟
	// 
	// 
	// 
	// C语言
	int* pp1 = (int*)malloc(sizeof(int));
	free(pp1);
	//
	// 
	// C++
	int* p1 = new int;
	delete p1;
	//
	// 1.不是函数调用，是new操作符，new一个int类型的对象
	// 2.不需要强制类型转化
	




	// 多个对象开辟
	// 
	// 
	// C语言
	int* pp2 = (int*)malloc(sizeof(int) * 10);
	free(pp2);
	//
	// 
	// C++
	int* p2 = new int[10];
	delete[] p2;
	// 
	// 
	// 
	// 注意：
	// new不会对开辟的 内置类型对象空间 进行初始化
	// 
	// 




	// 增加new的原因    ----     为自定义类型
	//
	// C语言
	A* pp3 = (A*)malloc(sizeof(A) * 10);
	free(pp3);
	//
	// 
	// C++
	A* p3 = new A(1);//new一个A类型的对象
	//A* p4 = &A(1);// 实例化一个匿名对象，将匿名对象的地址给p4指针   ----   但执行完成后匿名对象会直接析构销毁
	delete p3;
	// 
	// 
	// 注意：
	// new会对开辟的 自定义类型对象空间 调用构造函数进行实例化（定义初始化）
	// 
	// delete 调用对应 自定类型对象 的析构函数，并释放空间
	// 


	return 0;
}
// 
// 
//
